home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / KPlib 1.3.5 / KPQueue.h < prev    next >
Text File  |  1995-12-17  |  5KB  |  218 lines
  1. // A module of KPlib v1.3.5.
  2. // Written by Keith Pomakis during the summer of 1994.
  3. // Released to the public domain on October 10, 1994.
  4.  
  5. #ifndef KP_QUEUE_DEFINED
  6. #define KP_QUEUE_DEFINED
  7.  
  8. #include <stdlib.h>
  9. #include "KPbasic.h"
  10. #include "KPList.h"
  11.  
  12. // Assumes Element has a default constructor and operator=().
  13.  
  14. template <class Element>
  15. class KPQueue {
  16.     public:
  17.         KPQueue();
  18.         KPQueue(const KPQueue<Element> &queue);
  19.         KPQueue(const KPList<Element> &list);
  20.         KPQueue(const Element &element);
  21.         ~KPQueue();
  22.         operator KPList<Element>() const;
  23.         KPQueue<Element> &operator=(const KPQueue<Element> &queue);
  24.         KPQueue<Element> &operator=(const Element &element);
  25.         KPQueue<Element> &enqueue(const Element &element);
  26.         Element dequeue();
  27.         Element &head();
  28.         const Element &head() const;
  29.         Element &tail();
  30.         const Element &tail() const;
  31.         int size() const;
  32.         bool is_empty() const;
  33.         KPQueue<Element> &clear();
  34.     protected:
  35.         static void queue_empty_error(const char *fname);
  36.         KPList<Element> my_list;
  37. };
  38.  
  39. /****************************************************************************/
  40.  
  41. template <class Element>
  42. inline
  43. KPQueue<Element>::KPQueue(): my_list()
  44. { /* do nothing */ }
  45.  
  46. /****************************************************************************/
  47.  
  48. template <class Element>
  49. inline
  50. KPQueue<Element>::KPQueue(const KPQueue<Element> &queue): my_list(queue.my_list)
  51. { /* do nothing */ }
  52.  
  53. /****************************************************************************/
  54.  
  55. template <class Element>
  56. inline
  57. KPQueue<Element>::KPQueue(const KPList<Element> &list): my_list(list)
  58. { /* do nothing */ }
  59.  
  60. /****************************************************************************/
  61.  
  62. template <class Element>
  63. inline
  64. KPQueue<Element>::KPQueue(const Element &element): my_list(element)
  65. { /* do nothing */ }
  66.  
  67. /****************************************************************************/
  68.  
  69. template <class Element>
  70. inline
  71. KPQueue<Element>::~KPQueue()
  72. {
  73.     my_list.clear();
  74. }
  75.  
  76. /****************************************************************************/
  77.  
  78. template <class Element>
  79. inline
  80. KPQueue<Element>::operator KPList<Element>() const
  81. {
  82.     return my_list;
  83. }
  84.  
  85. /****************************************************************************/
  86.  
  87. template <class Element>
  88. inline KPQueue<Element> &
  89. KPQueue<Element>::operator=(const KPQueue<Element> &queue)
  90. {
  91.     my_list = queue.my_list;
  92.     return *this;
  93. }
  94.  
  95. /****************************************************************************/
  96.  
  97. template <class Element>
  98. inline KPQueue<Element> &
  99. KPQueue<Element>::operator=(const Element &element)
  100. {
  101.     my_list = element;
  102.     return *this;
  103. }
  104.  
  105. /****************************************************************************/
  106.  
  107. template <class Element>
  108. inline KPQueue<Element> &
  109. KPQueue<Element>::enqueue(const Element &element)
  110. {
  111.     my_list.add_to_tail(element);
  112.     return *this;
  113. }
  114.  
  115. /****************************************************************************/
  116.  
  117. template <class Element>
  118. inline Element
  119. KPQueue<Element>::dequeue()
  120. {
  121.     if (my_list.size() < 1)
  122.         queue_empty_error("dequeue()");
  123.     
  124.     Element element = my_list.head();
  125.     my_list.remove_head();
  126.     return element;
  127. }
  128.  
  129. /****************************************************************************/
  130.  
  131. template <class Element>
  132. inline Element &
  133. KPQueue<Element>::head()
  134. {
  135.     if (my_list.size() < 1)
  136.         queue_empty_error("head()");
  137.  
  138.     return my_list.head();
  139. }
  140.  
  141. /****************************************************************************/
  142.  
  143. template <class Element>
  144. inline const Element &
  145. KPQueue<Element>::head() const
  146. {
  147.     if (my_list.size() < 1)
  148.         queue_empty_error("head()");
  149.  
  150.     return my_list.head();
  151. }
  152.  
  153. /****************************************************************************/
  154.  
  155. template <class Element>
  156. inline Element &
  157. KPQueue<Element>::tail()
  158. {
  159.     if (my_list.size() < 1)
  160.         queue_empty_error("tail()");
  161.  
  162.     return my_list.tail();
  163. }
  164.  
  165. /****************************************************************************/
  166.  
  167. template <class Element>
  168. inline const Element &
  169. KPQueue<Element>::tail() const
  170. {
  171.     if (my_list.size() < 1)
  172.         queue_empty_error("tail()");
  173.  
  174.     return my_list.tail();
  175. }
  176.  
  177. /****************************************************************************/
  178.  
  179. template <class Element>
  180. inline int
  181. KPQueue<Element>::size() const
  182. {
  183.     return my_list.size();
  184. }
  185.  
  186. /****************************************************************************/
  187.  
  188. template <class Element>
  189. inline bool
  190. KPQueue<Element>::is_empty() const
  191. {
  192.     return my_list.is_empty();
  193. }
  194.  
  195. /****************************************************************************/
  196.  
  197. template <class Element>
  198. inline KPQueue<Element> &
  199. KPQueue<Element>::clear()
  200. {
  201.     my_list.clear();
  202.     return *this;
  203. }
  204.  
  205. /****************************************************************************/
  206.  
  207. template <class Element>
  208. void
  209. KPQueue<Element>::queue_empty_error(const char *fname)
  210. {
  211.     cerr << "KPQueue: " << fname << " - queue empty\n";
  212.     exit(EXIT_FAILURE);
  213. }
  214.  
  215. /****************************************************************************/
  216.  
  217. #endif /* KP_QUEUE_DEFINED */
  218.